32bitIEEE-from-scratch.js ➔ describe(ꞌcreate 32-bit IEEE wave file from scratchꞌ) - Code Metrics - Inspection of "wav.interleave() and wav.deInterleave()" - rochars/wavefile - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (2105e3)

by Rafael S.

created 2017-11-24 01:11 UTC

32bitIEEE-from-scratch.js ➔ describe(ꞌcreate 32-bit IEEE wave file from scratchꞌ) B

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines

520

Duplication

Lines	520
Ratio	100 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
c	1
b	0
f	0
nc	1
nop	0
dl	520
loc	520
rs	8.2857

How to fix Long Method

/*!
 * riffwave64
 * Read & write wave files with 8, 16, 24, 32 PCM, 32 IEEE & 64-bit data.
 * Copyright (c) 2017 Rafael da Silva Rocha.
 * https://github.com/rochars/riffwave64
 * https://tr2099.github.io
 *
 */
 
var assert = require('assert');

describe('create 32-bit IEEE wave file from scratch', function() {
    
    let wavefile = require('../../index.js');
    let wav = new wavefile.WaveFile();
    wav.fromScratch(1, 44100, '32f', [0, 0.04029441, -0.04029440, 1]);

    let fs = require('fs');
    fs.writeFileSync("./test/files/out/32-bitIEEE-441kHz-mono-fromScratch.wav", wav.toBytes());

    it('chunkId should be "RIFF"', function() {
        assert.equal(wav.chunkId, "RIFF");
    });

    it('format should be "WAVE"', function() {
        assert.equal(wav.format, "WAVE");
    });

    it('subChunk1Id should be "fmt "', function() {
        assert.equal(wav.subChunk1Id, "fmt ");
    });

    it('subChunk1Size should be 16', function() {
        assert.equal(wav.subChunk1Size, 16);
    });

    it('audioFormat should be 3', function() {
        assert.equal(wav.audioFormat, 3);
    });

    it('numChannels should be 1', function() {
        assert.equal(wav.numChannels, 1);
    });

    it('sampleRate should be 44100', function() {
        assert.equal(wav.sampleRate, 44100);
    });

    it('byteRate should be 176400', function() {
        assert.equal(wav.byteRate, 176400);
    });

    it('blockAlign should be 4', function() {
        assert.equal(wav.blockAlign, 4);
    });

    it('bitsPerSample should be 32', function() {
        assert.equal(wav.bitsPerSample, 32);
    });

    it('subChunk2Id should be "data"', function() {
        assert.equal(wav.subChunk2Id, "data");
    });

    it('subChunk2Size should be 16', function() {
        assert.equal(wav.subChunk2Size, 16);
    });

    it('samples_ should be the same as the args', function() {
        assert.deepEqual(wav.samples_, [0, 0.04029441, -0.04029440, 1]);
    });

    it('bitDepth_ should be "24"', function() {
        assert.equal(wav.bitDepth_, "32f");
    });

    /*
    it('should return a 8-bit wave file with an odd number of samples',
            function() {
        let wav = rw64.writeWavBytes(1, 48000, '8', [0, 255, 2]);
        let wavRead = rw64.readWavBytes(wav);

        assert.equal(wavRead.audioFormat, 1);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.blockAlign, 1);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.bitsPerSample, 8);
        assert.deepEqual(wavRead.samples, [0, 255, 2]);
    });

    it('should return a 16-bit wave file', function() {
        let wav = rw64.writeWavBytes(1, 48000, '16',
            [0, 1, -32768, 32767]);
        let wavRead = rw64.readWavBytes(wav);
        
        assert.equal(wavRead.audioFormat, 1);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.blockAlign, 2);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.bitsPerSample, 16);
        assert.deepEqual(wavRead.samples, [0, 1, -32768, 32767]);
    });

    it('should return a 16-bit wave file with a odd number of samples',
            function() {
        let wav = rw64.writeWavBytes(1, 48000, '16',
            [0, 1, -32768, 32767, 4]);
        let wavRead = rw64.readWavBytes(wav);
        
        assert.equal(wavRead.audioFormat, 1);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.blockAlign, 2);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.bitsPerSample, 16);
        assert.deepEqual(wavRead.samples, [0, 1, -32768, 32767, 4]);
    });

    it('should return a 24-bit wave file', function() {
        let wav = rw64.writeWavBytes(1, 48000, '24',
            [0, 1, -8388608, 8388607]);
        let wavRead = rw64.readWavBytes(wav);
        
        assert.equal(wavRead.audioFormat, 1);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.blockAlign, 3);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.bitsPerSample, 24);
        assert.equal(wavRead.subChunk2Size, 12); // 4 x 3
        assert.deepEqual(wavRead.samples, [0, 1, -8388608, 8388607]);
    });

    it('should return a 24-bit wave file with a odd number of samples',
            function() {
        let wav = rw64.writeWavBytes(1, 48000, '24',
            [0, 1, -8388608, 8388607, 4]);
        let wavRead = rw64.readWavBytes(wav);
        
        assert.equal(wavRead.audioFormat, 1);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.bitsPerSample, 24);
        assert.equal(wavRead.blockAlign, 3);
        assert.equal(wavRead.subChunk2Size, 15); // 5 x 3
        assert.deepEqual(wavRead.samples, [0, 1, -8388608, 8388607, 4]);
    });

    it('should return a 32-bit PCM wave file', function() {
        let wav = rw64.writeWavBytes(1, 44100, '32',
            [0, -2147483648, 2147483647, 4]);
        let wavRead = rw64.readWavBytes(wav);
        
        assert.equal(wavRead.audioFormat, 1);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 44100);
        assert.equal(wavRead.bitsPerSample, 32);
        assert.equal(wavRead.blockAlign, 4);
        assert.deepEqual(wavRead.samples, [0, -2147483648, 2147483647, 4]);
    });

    it('should return a 32-bit PCM wave file with a odd number of samples',
            function() {
        let wav = rw64.writeWavBytes(1, 44100, '32',
            [0, -2147483648, 45, 0, 1]);
        let wavRead = rw64.readWavBytes(wav);
        
        assert.equal(wavRead.audioFormat, 1);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 44100);
        assert.equal(wavRead.bitsPerSample, 32);
        assert.equal(wavRead.blockAlign, 4);
        assert.deepEqual(wavRead.samples, [0, -2147483648, 45, 0, 1]);
    });

    it('should return a 32-bit IEEE wave file', function() {
        let wav = rw64.writeWavBytes(1, 48000, '32f',
            [0, 0.04029441, -0.04029440, 1, -1, 0]);
        let wavRead = rw64.readWavBytes(wav);
        
        assert.equal(wavRead.audioFormat, 3);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.blockAlign, 4);
        assert.equal(wavRead.bitsPerSample, 32);
        for (let i=0; i<wavRead.samples.length; i++) {
            wavRead.samples[i] = Number((wavRead.samples[i]).toFixed(8));
        }
        assert.deepEqual(wavRead.samples,
            [0, 0.04029441, -0.04029440, 1, -1, 0]);
    });

    it('should return a 32-bit IEEE wave file ' +
        'with a odd number of samples',
            function() {
        let wav = rw64.writeWavBytes(1, 48000, '32f',
            [0, 0.04029441, -0.04029440, 1, -1, 0, 1]);
        let wavRead = rw64.readWavBytes(wav);
        
        assert.equal(wavRead.audioFormat, 3);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.blockAlign, 4);
        assert.equal(wavRead.bitsPerSample, 32);
        for (let i=0; i<wavRead.samples.length; i++) {
            wavRead.samples[i] = Number((wavRead.samples[i]).toFixed(8));
        }
        assert.deepEqual(wavRead.samples,
            [0, 0.04029441, -0.04029440, 1, -1, 0, 1]);
    });

    it('should return a wave file with 64-bit audio', function() {
        let wav = rw64.writeWavBytes(1, 48000, '64',
            [0.0, 0.04029440055111987, -0.04029440055111987, 1.0]);
        let wavRead = rw64.readWavBytes(wav);

        assert.equal(wavRead.audioFormat, 3);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.blockAlign, 8);
        assert.equal(wavRead.bitsPerSample, 64);
        assert.deepEqual(wavRead.samples,
            [0.0, 0.04029440055111987, -0.04029440055111987, 1.0]);
    });

    it('should return a wave file with 64-bit ' +
        'audio and a odd number of samples',
            function() {
        let wav = rw64.writeWavBytes(1, 48000, '64',
            [0.0, 0.04029440055111987, -0.04029440055111987, 1.0, 1]);
        let wavRead = rw64.readWavBytes(wav);

        assert.equal(wavRead.audioFormat, 3);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.blockAlign, 8);
        assert.equal(wavRead.bitsPerSample, 64);
        assert.deepEqual(wavRead.samples,
            [0.0, 0.04029440055111987, -0.04029440055111987, 1, 1]);
    });

    it('check rouding for double values on read/write',
            function() {
        let wav = rw64.writeWavBytes(1, 48000, '64',
            [3.141592653589793]);
        let wavRead = rw64.readWavBytes(wav);
        
        assert.ok(wavRead.samples[0] ==
            3.141592653589793);

    });

    it('check rouding for double values on read/write (forced change)',
        function() {
        let wav = rw64.writeWavBytes(1, 48000, '64',
            [3.141592653589793]);
        let wavRead = rw64.readWavBytes(wav);
        
        assert.ok(wavRead.samples[0] !=
            3.141592653589792);
    });

    it('should return a wave file with 64-bit audio on max and min range',
            function() {
        let wav = rw64.writeWavBytes(1, 48000, '64', [0,1,0,-1]);
        let wavRead = rw64.readWavBytes(wav);

        assert.equal(wavRead.audioFormat, 3);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.blockAlign, 8);
        assert.equal(wavRead.bitsPerSample, 64);
        assert.deepEqual(wavRead.samples, [0,1,0,-1]);
    });

    it('should return another wave file with 64-bit audio', function() {
        let wav = rw64.writeWavBytes(1, 48000, '64',
            [0.0, 0.99999999999999999, -0.00000000000000001, 1]);
        let wavRead = rw64.readWavBytes(wav);

        assert.equal(wavRead.audioFormat, 3);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.blockAlign, 8);
        assert.equal(wavRead.bitsPerSample, 64);
        assert.deepEqual(wavRead.samples,
            [0, 0.99999999999999999, -0.00000000000000001, 1]);
    });

    it('should return one more wave file with 64-bit audio', function() {
        let wav = rw64.writeWavBytes(1, 48000, '64',
            [0, 1, 1, -1, 0, -1, 0.99999999999999999,
            -0.00000000000000001, 1]);
        let wavRead = rw64.readWavBytes(wav);

        assert.equal(wavRead.audioFormat, 3);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.blockAlign, 8);
        assert.equal(wavRead.bitsPerSample, 64);
        assert.deepEqual(wavRead.samples,
            [0, 1, 1, -1, 0, -1, 0.99999999999999999,
            -0.00000000000000001, 1]);
    });

    it('should return a 24-bit wave file with 8 channels', function() {
        let wav = rw64.writeWavBytes(8, 48000, '24',
            [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1]);
        let read = rw64.readWavBytes(wav);
        
        assert.equal(read.subChunk1Size, 16);
        assert.equal(read.audioFormat, 1);
        assert.equal(read.numChannels, 8);
        assert.equal(read.sampleRate, 48000);
        assert.equal(read.blockAlign, 24);
        assert.equal(read.bitsPerSample, 24);
    });

    it('should return a 32-bit PCM wave file with 7 channels', function() {
        let wav = rw64.writeWavBytes(7, 48000, '32',
            [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1]);
        let read = rw64.readWavBytes(wav);
        
        assert.equal(read.subChunk1Size, 16);
        assert.equal(read.audioFormat, 1);
        assert.equal(read.numChannels, 7);
        assert.equal(read.sampleRate, 48000);
        assert.equal(read.blockAlign, 28);
        assert.equal(read.bitsPerSample, 32);
    });

    it('should return a 24-bit wave file encoded as a base 64 string',
            function() {
        assert.ok(rw64.writeWavBase64(1, 48000, '24',
            [0, 0.5, -0.5]));
    });

    it('should return a 32-bit IEEE wave file encoded as a base 64 string',
            function() {
        assert.ok(rw64.writeWavBase64(1, 48000, '32f',
            [0, 0.5, -0.5]));
    });

    it('should return a 64-bit wave file encoded as a base 64 string',
            function() {
        assert.ok(rw64.writeWavBase64(1, 48000, '64',
            [0, 0.5, -0.5]));
    });

    it('should return a 24-bit wave file encoded as a Data URI',
            function() {
        assert.ok(rw64.writeWavDataURI(1, 48000, '24',
            [0, 0.5, -0.5]));
    });

    it('should return a 32-bit IEEE wave file encoded as a Data URI',
            function() {
        assert.ok(rw64.writeWavDataURI(1, 48000, '32f',
            [0, 0.5, -0.5]));
    });

    it('should return a 64-bit wave file encoded as a Data URI',
            function() {
        assert.ok(rw64.writeWavDataURI(1, 48000, '64',
            [0, 0.5, -0.5]));
    });

    it('should return another 64-bit wave file encoded as a Data URI',
            function() {
        assert.ok(rw64.writeWavDataURI(1, 48000, '64',
            [0, 1, -1, 0, 1]));
    });

    it('should write a 8-bit wav file with 1 Hz sample rate',
            function() {
        let samples = [0,1];
        let wav = rw64.writeWavBytes(1, 1, '8', samples);
        let read = rw64.readWavBytes(wav);
        
        assert.equal(read.subChunk1Size, 16);
        assert.equal(read.audioFormat, 1);
        assert.equal(read.numChannels, 1);
        assert.equal(read.sampleRate, 1);
        assert.equal(read.blockAlign, 1);
        assert.equal(read.bitsPerSample, 8);
    });

    it('should write a 8-bit stereo wav file', function() {
        let channels = [
            [0,1,2],
            [0,1,2]
        ];
        let samples = rw64.interleave(channels);
        let wav = rw64.writeWavBytes(2, 44100, '8', samples);
        let read = rw64.readWavBytes(wav);
        
        assert.equal(read.subChunk1Size, 16);
        assert.equal(read.audioFormat, 1);
        assert.equal(read.numChannels, 2);
        assert.equal(read.sampleRate, 44100);
        assert.equal(read.blockAlign, 2);
        assert.equal(read.bitsPerSample, 8);
    });

    it('should write a 16-bit stereo wav file', function() {
        let channels = [
            [0,1,2],
            [0,1,2]
        ];
        let samples = rw64.interleave(channels);
        let wav = rw64.writeWavBytes(2, 44100, '16', samples);
        let read = rw64.readWavBytes(wav);
        
        assert.equal(read.subChunk1Size, 16);
        assert.equal(read.audioFormat, 1);
        assert.equal(read.numChannels, 2);
        assert.equal(read.sampleRate, 44100);
        assert.equal(read.blockAlign, 4);
        assert.equal(read.bitsPerSample, 16);
    });

    it('should write a 24-bit stereo wav file', function() {
        let channels = [
            [0,1,2],
            [0,1,2]
        ];
        let samples = rw64.interleave(channels);
        let wav = rw64.writeWavBytes(2, 44100, '24', samples);
        let read = rw64.readWavBytes(wav);
        
        assert.equal(read.subChunk1Size, 16);
        assert.equal(read.audioFormat, 1);
        assert.equal(read.numChannels, 2);
        assert.equal(read.sampleRate, 44100);
        assert.equal(read.blockAlign, 6);
        assert.equal(read.bitsPerSample, 24);
    });

    it('should write a 24-bit stereo wav file', function() {
        let channels = [
            [0,1,2],
            [0,1,2]
        ];
        let samples = rw64.interleave(channels);
        let wav = rw64.writeWavBytes(2, 44100, '24', samples);
        let read = rw64.readWavBytes(wav);
        
        assert.equal(read.subChunk1Size, 16);
        assert.equal(read.audioFormat, 1);
        assert.equal(read.numChannels, 2);
        assert.equal(read.sampleRate, 44100);
        assert.equal(read.blockAlign, 6);
        assert.equal(read.bitsPerSample, 24);
    });

    it('should write a 32-bit PCM stereo wav file', function() {
        let channels = [
            [0,1,2],
            [0,1,2]
        ];
        let samples = rw64.interleave(channels);
        let wav = rw64.writeWavBytes(2, 44100, '32', samples);
        let read = rw64.readWavBytes(wav);
        
        assert.equal(read.subChunk1Size, 16);
        assert.equal(read.audioFormat, 1);
        assert.equal(read.numChannels, 2);
        assert.equal(read.sampleRate, 44100);
        assert.equal(read.blockAlign, 8);
        assert.equal(read.bitsPerSample, 32);
    });

    it('should write a 32-bit IEEE stereo wav file', function() {
        let channels = [
            [0,1,-1],
            [0,1,-1]
        ];
        let samples = rw64.interleave(channels);
        let wav = rw64.writeWavBytes(2, 44100, '32f', samples);
        let read = rw64.readWavBytes(wav);
        
        assert.equal(read.subChunk1Size, 16);
        assert.equal(read.audioFormat, 3);
        assert.equal(read.numChannels, 2);
        assert.equal(read.sampleRate, 44100);
        assert.equal(read.blockAlign, 8);
        assert.equal(read.bitsPerSample, 32);
    });

    it('should write a 64-bit stereo wav file', function() {
        let channels = [
            [0,1,-1],
            [0,1,-1]
        ];
        let samples = rw64.interleave(channels);
        let wav = rw64.writeWavBytes(2, 44100, '64', samples);
        let read = rw64.readWavBytes(wav);
        
        assert.equal(read.subChunk1Size, 16);
        assert.equal(read.audioFormat, 3);
        assert.equal(read.numChannels, 2);
        assert.equal(read.sampleRate, 44100);
        assert.equal(read.blockAlign, 16);
        assert.equal(read.bitsPerSample, 64);
    });

    it('should return a 64-bit wave file with non-negative 0',
            function() {
        let wav = rw64.writeWavBytes(1, 48000, '64', [0, 1, -1, -0, 1]);
        let wavRead = rw64.readWavBytes(wav);
        assert.equal(wavRead.audioFormat, 3);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 48000);
        assert.equal(wavRead.blockAlign, 8);
        assert.equal(wavRead.bitsPerSample, 64);
        assert.deepEqual(wavRead.samples, [0, 1, -1, 0, 1]);
    });

    it('should return a 32-bit PCM file with max possible sample value',
            function() {
        let wav = rw64.writeWavBytes(1, 16000, '32',
            [-2147483648, 2147483647, -1, 1, 0]);
        let wavRead = rw64.readWavBytes(wav);
        assert.equal(wavRead.audioFormat, 1);
        assert.equal(wavRead.numChannels, 1);
        assert.equal(wavRead.sampleRate, 16000);
        assert.equal(wavRead.blockAlign, 4);
        assert.equal(wavRead.bitsPerSample, 32);
        assert.deepEqual(wavRead.samples,
            [-2147483648, 2147483647, -1, 1, 0]);
    });
    */
});


1			/*!
2			* riffwave64
3			* Read & write wave files with 8, 16, 24, 32 PCM, 32 IEEE & 64-bit data.
4			* Copyright (c) 2017 Rafael da Silva Rocha.
5			* https://github.com/rochars/riffwave64
6			* https://tr2099.github.io
7			*
8			*/
9
10			var assert = require('assert');
11
12			describe('create 32-bit IEEE wave file from scratch', function() {
13
14			let wavefile = require('../../index.js');
15			let wav = new wavefile.WaveFile();
16			wav.fromScratch(1, 44100, '32f', [0, 0.04029441, -0.04029440, 1]);
17
18			let fs = require('fs');
19			fs.writeFileSync("./test/files/out/32-bitIEEE-441kHz-mono-fromScratch.wav", wav.toBytes());
20
21			it('chunkId should be "RIFF"', function() {
22			assert.equal(wav.chunkId, "RIFF");
23			});
24
25			it('format should be "WAVE"', function() {
26			assert.equal(wav.format, "WAVE");
27			});
28
29			it('subChunk1Id should be "fmt "', function() {
30			assert.equal(wav.subChunk1Id, "fmt ");
31			});
32
33			it('subChunk1Size should be 16', function() {
34			assert.equal(wav.subChunk1Size, 16);
35			});
36
37			it('audioFormat should be 3', function() {
38			assert.equal(wav.audioFormat, 3);
39			});
40
41			it('numChannels should be 1', function() {
42			assert.equal(wav.numChannels, 1);
43			});
44
45			it('sampleRate should be 44100', function() {
46			assert.equal(wav.sampleRate, 44100);
47			});
48
49			it('byteRate should be 176400', function() {
50			assert.equal(wav.byteRate, 176400);
51			});
52
53			it('blockAlign should be 4', function() {
54			assert.equal(wav.blockAlign, 4);
55			});
56
57			it('bitsPerSample should be 32', function() {
58			assert.equal(wav.bitsPerSample, 32);
59			});
60
61			it('subChunk2Id should be "data"', function() {
62			assert.equal(wav.subChunk2Id, "data");
63			});
64
65			it('subChunk2Size should be 16', function() {
66			assert.equal(wav.subChunk2Size, 16);
67			});
68
69			it('samples_ should be the same as the args', function() {
70			assert.deepEqual(wav.samples_, [0, 0.04029441, -0.04029440, 1]);
71			});
72
73			it('bitDepth_ should be "24"', function() {
74			assert.equal(wav.bitDepth_, "32f");
75			});
76
77			/*
78			it('should return a 8-bit wave file with an odd number of samples',
79			function() {
80			let wav = rw64.writeWavBytes(1, 48000, '8', [0, 255, 2]);
81			let wavRead = rw64.readWavBytes(wav);
82
83			assert.equal(wavRead.audioFormat, 1);
84			assert.equal(wavRead.numChannels, 1);
85			assert.equal(wavRead.blockAlign, 1);
86			assert.equal(wavRead.sampleRate, 48000);
87			assert.equal(wavRead.bitsPerSample, 8);
88			assert.deepEqual(wavRead.samples, [0, 255, 2]);
89			});
90
91			it('should return a 16-bit wave file', function() {
92			let wav = rw64.writeWavBytes(1, 48000, '16',
93			[0, 1, -32768, 32767]);
94			let wavRead = rw64.readWavBytes(wav);
95
96			assert.equal(wavRead.audioFormat, 1);
97			assert.equal(wavRead.numChannels, 1);
98			assert.equal(wavRead.blockAlign, 2);
99			assert.equal(wavRead.sampleRate, 48000);
100			assert.equal(wavRead.bitsPerSample, 16);
101			assert.deepEqual(wavRead.samples, [0, 1, -32768, 32767]);
102			});
103
104			it('should return a 16-bit wave file with a odd number of samples',
105			function() {
106			let wav = rw64.writeWavBytes(1, 48000, '16',
107			[0, 1, -32768, 32767, 4]);
108			let wavRead = rw64.readWavBytes(wav);
109
110			assert.equal(wavRead.audioFormat, 1);
111			assert.equal(wavRead.numChannels, 1);
112			assert.equal(wavRead.blockAlign, 2);
113			assert.equal(wavRead.sampleRate, 48000);
114			assert.equal(wavRead.bitsPerSample, 16);
115			assert.deepEqual(wavRead.samples, [0, 1, -32768, 32767, 4]);
116			});
117
118			it('should return a 24-bit wave file', function() {
119			let wav = rw64.writeWavBytes(1, 48000, '24',
120			[0, 1, -8388608, 8388607]);
121			let wavRead = rw64.readWavBytes(wav);
122
123			assert.equal(wavRead.audioFormat, 1);
124			assert.equal(wavRead.numChannels, 1);
125			assert.equal(wavRead.blockAlign, 3);
126			assert.equal(wavRead.sampleRate, 48000);
127			assert.equal(wavRead.bitsPerSample, 24);
128			assert.equal(wavRead.subChunk2Size, 12); // 4 x 3
129			assert.deepEqual(wavRead.samples, [0, 1, -8388608, 8388607]);
130			});
131
132			it('should return a 24-bit wave file with a odd number of samples',
133			function() {
134			let wav = rw64.writeWavBytes(1, 48000, '24',
135			[0, 1, -8388608, 8388607, 4]);
136			let wavRead = rw64.readWavBytes(wav);
137
138			assert.equal(wavRead.audioFormat, 1);
139			assert.equal(wavRead.numChannels, 1);
140			assert.equal(wavRead.sampleRate, 48000);
141			assert.equal(wavRead.bitsPerSample, 24);
142			assert.equal(wavRead.blockAlign, 3);
143			assert.equal(wavRead.subChunk2Size, 15); // 5 x 3
144			assert.deepEqual(wavRead.samples, [0, 1, -8388608, 8388607, 4]);
145			});
146
147			it('should return a 32-bit PCM wave file', function() {
148			let wav = rw64.writeWavBytes(1, 44100, '32',
149			[0, -2147483648, 2147483647, 4]);
150			let wavRead = rw64.readWavBytes(wav);
151
152			assert.equal(wavRead.audioFormat, 1);
153			assert.equal(wavRead.numChannels, 1);
154			assert.equal(wavRead.sampleRate, 44100);
155			assert.equal(wavRead.bitsPerSample, 32);
156			assert.equal(wavRead.blockAlign, 4);
157			assert.deepEqual(wavRead.samples, [0, -2147483648, 2147483647, 4]);
158			});
159
160			it('should return a 32-bit PCM wave file with a odd number of samples',
161			function() {
162			let wav = rw64.writeWavBytes(1, 44100, '32',
163			[0, -2147483648, 45, 0, 1]);
164			let wavRead = rw64.readWavBytes(wav);
165
166			assert.equal(wavRead.audioFormat, 1);
167			assert.equal(wavRead.numChannels, 1);
168			assert.equal(wavRead.sampleRate, 44100);
169			assert.equal(wavRead.bitsPerSample, 32);
170			assert.equal(wavRead.blockAlign, 4);
171			assert.deepEqual(wavRead.samples, [0, -2147483648, 45, 0, 1]);
172			});
173
174			it('should return a 32-bit IEEE wave file', function() {
175			let wav = rw64.writeWavBytes(1, 48000, '32f',
176			[0, 0.04029441, -0.04029440, 1, -1, 0]);
177			let wavRead = rw64.readWavBytes(wav);
178
179			assert.equal(wavRead.audioFormat, 3);
180			assert.equal(wavRead.numChannels, 1);
181			assert.equal(wavRead.sampleRate, 48000);
182			assert.equal(wavRead.blockAlign, 4);
183			assert.equal(wavRead.bitsPerSample, 32);
184			for (let i=0; i<wavRead.samples.length; i++) {
185			wavRead.samples[i] = Number((wavRead.samples[i]).toFixed(8));
186			}
187			assert.deepEqual(wavRead.samples,
188			[0, 0.04029441, -0.04029440, 1, -1, 0]);
189			});
190
191			it('should return a 32-bit IEEE wave file ' +
192			'with a odd number of samples',
193			function() {
194			let wav = rw64.writeWavBytes(1, 48000, '32f',
195			[0, 0.04029441, -0.04029440, 1, -1, 0, 1]);
196			let wavRead = rw64.readWavBytes(wav);
197
198			assert.equal(wavRead.audioFormat, 3);
199			assert.equal(wavRead.numChannels, 1);
200			assert.equal(wavRead.sampleRate, 48000);
201			assert.equal(wavRead.blockAlign, 4);
202			assert.equal(wavRead.bitsPerSample, 32);
203			for (let i=0; i<wavRead.samples.length; i++) {
204			wavRead.samples[i] = Number((wavRead.samples[i]).toFixed(8));
205			}
206			assert.deepEqual(wavRead.samples,
207			[0, 0.04029441, -0.04029440, 1, -1, 0, 1]);
208			});
209
210			it('should return a wave file with 64-bit audio', function() {
211			let wav = rw64.writeWavBytes(1, 48000, '64',
212			[0.0, 0.04029440055111987, -0.04029440055111987, 1.0]);
213			let wavRead = rw64.readWavBytes(wav);
214
215			assert.equal(wavRead.audioFormat, 3);
216			assert.equal(wavRead.numChannels, 1);
217			assert.equal(wavRead.sampleRate, 48000);
218			assert.equal(wavRead.blockAlign, 8);
219			assert.equal(wavRead.bitsPerSample, 64);
220			assert.deepEqual(wavRead.samples,
221			[0.0, 0.04029440055111987, -0.04029440055111987, 1.0]);
222			});
223
224			it('should return a wave file with 64-bit ' +
225			'audio and a odd number of samples',
226			function() {
227			let wav = rw64.writeWavBytes(1, 48000, '64',
228			[0.0, 0.04029440055111987, -0.04029440055111987, 1.0, 1]);
229			let wavRead = rw64.readWavBytes(wav);
230
231			assert.equal(wavRead.audioFormat, 3);
232			assert.equal(wavRead.numChannels, 1);
233			assert.equal(wavRead.sampleRate, 48000);
234			assert.equal(wavRead.blockAlign, 8);
235			assert.equal(wavRead.bitsPerSample, 64);
236			assert.deepEqual(wavRead.samples,
237			[0.0, 0.04029440055111987, -0.04029440055111987, 1, 1]);
238			});
239
240			it('check rouding for double values on read/write',
241			function() {
242			let wav = rw64.writeWavBytes(1, 48000, '64',
243			[3.141592653589793]);
244			let wavRead = rw64.readWavBytes(wav);
245
246			assert.ok(wavRead.samples[0] ==
247			3.141592653589793);
248
249			});
250
251			it('check rouding for double values on read/write (forced change)',
252			function() {
253			let wav = rw64.writeWavBytes(1, 48000, '64',
254			[3.141592653589793]);
255			let wavRead = rw64.readWavBytes(wav);
256
257			assert.ok(wavRead.samples[0] !=
258			3.141592653589792);
259			});
260
261			it('should return a wave file with 64-bit audio on max and min range',
262			function() {
263			let wav = rw64.writeWavBytes(1, 48000, '64', [0,1,0,-1]);
264			let wavRead = rw64.readWavBytes(wav);
265
266			assert.equal(wavRead.audioFormat, 3);
267			assert.equal(wavRead.numChannels, 1);
268			assert.equal(wavRead.sampleRate, 48000);
269			assert.equal(wavRead.blockAlign, 8);
270			assert.equal(wavRead.bitsPerSample, 64);
271			assert.deepEqual(wavRead.samples, [0,1,0,-1]);
272			});
273
274			it('should return another wave file with 64-bit audio', function() {
275			let wav = rw64.writeWavBytes(1, 48000, '64',
276			[0.0, 0.99999999999999999, -0.00000000000000001, 1]);
277			let wavRead = rw64.readWavBytes(wav);
278
279			assert.equal(wavRead.audioFormat, 3);
280			assert.equal(wavRead.numChannels, 1);
281			assert.equal(wavRead.sampleRate, 48000);
282			assert.equal(wavRead.blockAlign, 8);
283			assert.equal(wavRead.bitsPerSample, 64);
284			assert.deepEqual(wavRead.samples,
285			[0, 0.99999999999999999, -0.00000000000000001, 1]);
286			});
287
288			it('should return one more wave file with 64-bit audio', function() {
289			let wav = rw64.writeWavBytes(1, 48000, '64',
290			[0, 1, 1, -1, 0, -1, 0.99999999999999999,
291			-0.00000000000000001, 1]);
292			let wavRead = rw64.readWavBytes(wav);
293
294			assert.equal(wavRead.audioFormat, 3);
295			assert.equal(wavRead.numChannels, 1);
296			assert.equal(wavRead.sampleRate, 48000);
297			assert.equal(wavRead.blockAlign, 8);
298			assert.equal(wavRead.bitsPerSample, 64);
299			assert.deepEqual(wavRead.samples,
300			[0, 1, 1, -1, 0, -1, 0.99999999999999999,
301			-0.00000000000000001, 1]);
302			});
303
304			it('should return a 24-bit wave file with 8 channels', function() {
305			let wav = rw64.writeWavBytes(8, 48000, '24',
306			[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1]);
307			let read = rw64.readWavBytes(wav);
308
309			assert.equal(read.subChunk1Size, 16);
310			assert.equal(read.audioFormat, 1);
311			assert.equal(read.numChannels, 8);
312			assert.equal(read.sampleRate, 48000);
313			assert.equal(read.blockAlign, 24);
314			assert.equal(read.bitsPerSample, 24);
315			});
316
317			it('should return a 32-bit PCM wave file with 7 channels', function() {
318			let wav = rw64.writeWavBytes(7, 48000, '32',
319			[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1]);
320			let read = rw64.readWavBytes(wav);
321
322			assert.equal(read.subChunk1Size, 16);
323			assert.equal(read.audioFormat, 1);
324			assert.equal(read.numChannels, 7);
325			assert.equal(read.sampleRate, 48000);
326			assert.equal(read.blockAlign, 28);
327			assert.equal(read.bitsPerSample, 32);
328			});
329
330			it('should return a 24-bit wave file encoded as a base 64 string',
331			function() {
332			assert.ok(rw64.writeWavBase64(1, 48000, '24',
333			[0, 0.5, -0.5]));
334			});
335
336			it('should return a 32-bit IEEE wave file encoded as a base 64 string',
337			function() {
338			assert.ok(rw64.writeWavBase64(1, 48000, '32f',
339			[0, 0.5, -0.5]));
340			});
341
342			it('should return a 64-bit wave file encoded as a base 64 string',
343			function() {
344			assert.ok(rw64.writeWavBase64(1, 48000, '64',
345			[0, 0.5, -0.5]));
346			});
347
348			it('should return a 24-bit wave file encoded as a Data URI',
349			function() {
350			assert.ok(rw64.writeWavDataURI(1, 48000, '24',
351			[0, 0.5, -0.5]));
352			});
353
354			it('should return a 32-bit IEEE wave file encoded as a Data URI',
355			function() {
356			assert.ok(rw64.writeWavDataURI(1, 48000, '32f',
357			[0, 0.5, -0.5]));
358			});
359
360			it('should return a 64-bit wave file encoded as a Data URI',
361			function() {
362			assert.ok(rw64.writeWavDataURI(1, 48000, '64',
363			[0, 0.5, -0.5]));
364			});
365
366			it('should return another 64-bit wave file encoded as a Data URI',
367			function() {
368			assert.ok(rw64.writeWavDataURI(1, 48000, '64',
369			[0, 1, -1, 0, 1]));
370			});
371
372			it('should write a 8-bit wav file with 1 Hz sample rate',
373			function() {
374			let samples = [0,1];
375			let wav = rw64.writeWavBytes(1, 1, '8', samples);
376			let read = rw64.readWavBytes(wav);
377
378			assert.equal(read.subChunk1Size, 16);
379			assert.equal(read.audioFormat, 1);
380			assert.equal(read.numChannels, 1);
381			assert.equal(read.sampleRate, 1);
382			assert.equal(read.blockAlign, 1);
383			assert.equal(read.bitsPerSample, 8);
384			});
385
386			it('should write a 8-bit stereo wav file', function() {
387			let channels = [
388			[0,1,2],
389			[0,1,2]
390			];
391			let samples = rw64.interleave(channels);
392			let wav = rw64.writeWavBytes(2, 44100, '8', samples);
393			let read = rw64.readWavBytes(wav);
394
395			assert.equal(read.subChunk1Size, 16);
396			assert.equal(read.audioFormat, 1);
397			assert.equal(read.numChannels, 2);
398			assert.equal(read.sampleRate, 44100);
399			assert.equal(read.blockAlign, 2);
400			assert.equal(read.bitsPerSample, 8);
401			});
402
403			it('should write a 16-bit stereo wav file', function() {
404			let channels = [
405			[0,1,2],
406			[0,1,2]
407			];
408			let samples = rw64.interleave(channels);
409			let wav = rw64.writeWavBytes(2, 44100, '16', samples);
410			let read = rw64.readWavBytes(wav);
411
412			assert.equal(read.subChunk1Size, 16);
413			assert.equal(read.audioFormat, 1);
414			assert.equal(read.numChannels, 2);
415			assert.equal(read.sampleRate, 44100);
416			assert.equal(read.blockAlign, 4);
417			assert.equal(read.bitsPerSample, 16);
418			});
419
420			it('should write a 24-bit stereo wav file', function() {
421			let channels = [
422			[0,1,2],
423			[0,1,2]
424			];
425			let samples = rw64.interleave(channels);
426			let wav = rw64.writeWavBytes(2, 44100, '24', samples);
427			let read = rw64.readWavBytes(wav);
428
429			assert.equal(read.subChunk1Size, 16);
430			assert.equal(read.audioFormat, 1);
431			assert.equal(read.numChannels, 2);
432			assert.equal(read.sampleRate, 44100);
433			assert.equal(read.blockAlign, 6);
434			assert.equal(read.bitsPerSample, 24);
435			});
436
437			it('should write a 24-bit stereo wav file', function() {
438			let channels = [
439			[0,1,2],
440			[0,1,2]
441			];
442			let samples = rw64.interleave(channels);
443			let wav = rw64.writeWavBytes(2, 44100, '24', samples);
444			let read = rw64.readWavBytes(wav);
445
446			assert.equal(read.subChunk1Size, 16);
447			assert.equal(read.audioFormat, 1);
448			assert.equal(read.numChannels, 2);
449			assert.equal(read.sampleRate, 44100);
450			assert.equal(read.blockAlign, 6);
451			assert.equal(read.bitsPerSample, 24);
452			});
453
454			it('should write a 32-bit PCM stereo wav file', function() {
455			let channels = [
456			[0,1,2],
457			[0,1,2]
458			];
459			let samples = rw64.interleave(channels);
460			let wav = rw64.writeWavBytes(2, 44100, '32', samples);
461			let read = rw64.readWavBytes(wav);
462
463			assert.equal(read.subChunk1Size, 16);
464			assert.equal(read.audioFormat, 1);
465			assert.equal(read.numChannels, 2);
466			assert.equal(read.sampleRate, 44100);
467			assert.equal(read.blockAlign, 8);
468			assert.equal(read.bitsPerSample, 32);
469			});
470
471			it('should write a 32-bit IEEE stereo wav file', function() {
472			let channels = [
473			[0,1,-1],
474			[0,1,-1]
475			];
476			let samples = rw64.interleave(channels);
477			let wav = rw64.writeWavBytes(2, 44100, '32f', samples);
478			let read = rw64.readWavBytes(wav);
479
480			assert.equal(read.subChunk1Size, 16);
481			assert.equal(read.audioFormat, 3);
482			assert.equal(read.numChannels, 2);
483			assert.equal(read.sampleRate, 44100);
484			assert.equal(read.blockAlign, 8);
485			assert.equal(read.bitsPerSample, 32);
486			});
487
488			it('should write a 64-bit stereo wav file', function() {
489			let channels = [
490			[0,1,-1],
491			[0,1,-1]
492			];
493			let samples = rw64.interleave(channels);
494			let wav = rw64.writeWavBytes(2, 44100, '64', samples);
495			let read = rw64.readWavBytes(wav);
496
497			assert.equal(read.subChunk1Size, 16);
498			assert.equal(read.audioFormat, 3);
499			assert.equal(read.numChannels, 2);
500			assert.equal(read.sampleRate, 44100);
501			assert.equal(read.blockAlign, 16);
502			assert.equal(read.bitsPerSample, 64);
503			});
504
505			it('should return a 64-bit wave file with non-negative 0',
506			function() {
507			let wav = rw64.writeWavBytes(1, 48000, '64', [0, 1, -1, -0, 1]);
508			let wavRead = rw64.readWavBytes(wav);
509			assert.equal(wavRead.audioFormat, 3);
510			assert.equal(wavRead.numChannels, 1);
511			assert.equal(wavRead.sampleRate, 48000);
512			assert.equal(wavRead.blockAlign, 8);
513			assert.equal(wavRead.bitsPerSample, 64);
514			assert.deepEqual(wavRead.samples, [0, 1, -1, 0, 1]);
515			});
516
517			it('should return a 32-bit PCM file with max possible sample value',
518			function() {
519			let wav = rw64.writeWavBytes(1, 16000, '32',
520			[-2147483648, 2147483647, -1, 1, 0]);
521			let wavRead = rw64.readWavBytes(wav);
522			assert.equal(wavRead.audioFormat, 1);
523			assert.equal(wavRead.numChannels, 1);
524			assert.equal(wavRead.sampleRate, 16000);
525			assert.equal(wavRead.blockAlign, 4);
526			assert.equal(wavRead.bitsPerSample, 32);
527			assert.deepEqual(wavRead.samples,
528			[-2147483648, 2147483647, -1, 1, 0]);
529			});
530			*/
531			});
532

rochars / wavefile

Branch — master (2105e3)

32bitIEEE-from-scratch.js ➔ describe(ꞌcreate 32-bit IEEE wave file from scratchꞌ) B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like